package test03;
import java.util.Scanner;
/*问题描述
　　输入一个仅包含小写英文字母的字符串，请问这个字符串中的最后一元音是什么。
　　在英文中，a, e, i, o, u 共 5 个字母是元音字母，其它字母不是元音字母。
输入格式
　　输入一行包含一个字符串，仅由小写英文字符组成，字符串中至少包含一个元音字母。
输出格式
　　输出一行包含一个字符，表示答案。
	样例输入
	lanqiao
	样例输出
	o
	样例输入
	cup
	样例输出
	u
 * 
 */
//public class Main {
//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//        String s = scanner.nextLine();
//        char[] vowels = {'a', 'e', 'i', 'o', 'u'};
//        char lastVowel = ' '; // 初始化为一个空格
//        for (int i = s.length() - 1; i >= 0; i--) {
//            char c = s.charAt(i);
//            if (isVowel(c, vowels)) {
//                lastVowel = c;
//                break;
//            }
//        }
//        System.out.println(lastVowel);
//    }
//
//    private static boolean isVowel(char c, char[] vowels) {
//        for (char vowel : vowels) {
//            if (c == vowel) {
//                return true;
//            }
//        }
//        return false;
//    }
//}


/*
 * 问题描述
　　小蓝站在一个 n 行 m 列的方格图中间，方格图的每一个方格上都标有一个正整数。
　　如果两个相邻方格（上下左右四个方向相邻）内的数的最大公约数大于 1 ，则可以从其中一个方格移动到另一个方格，当然也可以从另一个方格移回第一个方格。
　　假设小蓝开始时站在第 r 行第 c 列，请问小蓝可以移动到方格图内的多少个方格？
输入格式
　　输入的第一行包含两个整数 n, m ，用一个空格分隔，表示方格图的行数和列数。
　　接下来 n 行，每行包含 m 个正整数，相邻整数间用一个空格分隔，依次表示方格图中从第 1 行到第 n 行，每行从第 1 列到第 m 列中的数。
　　接下来一行包含两个整数 r, c，用一个空格分隔，表示小蓝所在的行号和列号。
输出格式
　　输出一行包含一个整数，表示答案。
样例输入
3 4
3 6 5 5
2 4 3 5
7 8 3 8
3 2
样例输出
5
评测用例规模与约定
　　对于50%的评测用例，1 <= n, m <= 100，方格图中的每个数不超过 10**5 （10的5次方）。
　　对于所有评测用例，1 <= n, m <= 1000，方格图中的每个数不超过 10**9 （10的9次方）。
 */
////import java.util.Scanner;
//
//public class Main {
//    static int[] dx = {-1, 0, 1, 0};
//    static int[] dy = {0, 1, 0, -1};
//
//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//        int n = scanner.nextInt();
//        int m = scanner.nextInt();
//
//        int[][] grid = new int[n][m];
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < m; j++) {
//                grid[i][j] = scanner.nextInt();
//            }
//        }
//
//        int r = scanner.nextInt();
//        int c = scanner.nextInt();
//
//        boolean[][] visited = new boolean[n][m];
//        int count = dfs(grid, visited, n, m, r - 1, c - 1);
//
//        System.out.println(count);
//    }
//
//    static int gcd(int a, int b) {
//        if (b == 0) {
//            return a;
//        }
//        return gcd(b, a % b);
//    }
//
//    static boolean isValid(int x, int y, int n, int m) {
//        return x >= 0 && x < n && y >= 0 && y < m;
//    }
//
//    static int dfs(int[][] grid, boolean[][] visited, int n, int m, int x, int y) {
//        visited[x][y] = true;
//        int count = 1;
//
//        for (int i = 0; i < 4; i++) {
//            int newX = x + dx[i];
//            int newY = y + dy[i];
//            if (isValid(newX, newY, n, m) && !visited[newX][newY]
//                    && gcd(grid[x][y], grid[newX][newY]) > 1) {
//                count += dfs(grid, visited, n, m, newX, newY);
//            }
//        }
//        return count;
//    }
//}
/*
 * 问题描述
　　给定一个整数，对这个整数的一次转换是指将这个整数变为这个整数的所有数位上的非零数字的乘积。
　　例如，对 123456789 进行一次转换变为 1*2*3*4*5*6*7*8*9=362880，再进行一次转换变为 3*6*2*8*8=2304，再进行一次转换变为 2*3*4=24，再进行一次转换变为 8。
　　给定一个整数，请依次将转换过程中经历的每个整数输出，直到小于 10 。
输入格式
　　输入一行包含一个整数 n 。
输出格式
　　输出多行，每行包含一个整数。
	样例输入
	123456789
	样例输出
	362880
	2304
	24
	8
评测用例规模与约定
　　对于 50% 的评测用例，1 <= n <= 10**9 （10的9次方）。
　　对于所有评测用例，1 <= n <= 10**18 （10的18次方）。
*/

//public class Main {
//	public static int multiplyDigits(int n) {
//        int product = 1;
//        while (n > 0) {
//            int digit = n % 10;
//            if (digit != 0) { // 忽略数位上的0
//                product *= digit;
//            }
//            n /= 10;
//        }
//        return product;
//    }
//	public static int main() {
//		try(Scanner sc=new Scanner(System.in)){
//		    int n=sc.nextInt();
//		    while (n >= 10) {
//            n = multiplyDigits(n);
//            System.out.printf("%d\n", n);
//        }
//         return 0;
//		}
//	}
//}

/*
 * 问题描述
　　给定一个序列 a[1], a[2], …, a[n] 和一个整数 k，请找出一个长度正好为 k 的区间，使得区间中所有数的和最大。
　　即要找到一个整数 p ，使得 1 <= p 且 p+k-1 <= n ，使得 a[p]+a[p+1]+...+a[p+k-1] 最大。
输入格式
　　输入的第一行包含两个整数 n , k。
　　第二行包含 n 个整数，相邻的整数之间使用一个空格分隔，表示给定的序列。
输出格式
　　输出一行包含一个整数，表示最大的区间和，你只需要输出和就行，不需要输出方案。
样例输入
6 3
2 3 9 1 9 5
样例输出
19
评测用例规模与约定
　　对于 30% 的评测用例，1 <= k <= n <= 30，1 <= a[i] <= 100。
　　对于 60% 的评测用例，1 <= k <= n <= 1000，1 <= a[i] <= 10000。
　　对于所有评测用例，1 <= k <= n <= 100000，1 <= a[i] <= 1000000。
 */
//import java.util.Scanner;
//public class Main {
//    public static void main(String[] args) {
//        Scanner scanner = new Scanner(System.in);
//        int n = scanner.nextInt();
//        int k = scanner.nextInt();
//        int[] nums = new int[n];
//        for (int i = 0; i < n; i++) {
//            nums[i] = scanner.nextInt();
//        }
//        int maxSum = findMaxSubarraySum(nums, k);
//        System.out.println(maxSum);
//    }
//
//    // 使用滑动窗口法求解最大子数组和
//    private static int findMaxSubarraySum(int[] nums, int k) {
//        int maxSum = 0;
//        int currentSum = 0;
//        for (int i = 0; i < k; i++) {
//            currentSum += nums[i];
//        }
//        maxSum = currentSum;
//        for (int i = k; i < nums.length; i++) {
//            currentSum += nums[i] - nums[i - k];
//            maxSum = Math.max(maxSum, currentSum);
//        }
//        return maxSum;
//    }
//}